
#include "Trajectoire.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>

const int pointEstValide (Point* ppoint, Terrain* pterrain)
{
	if (ppoint->posX_point>=0 && ppoint->posX_point<getDimX_terrain (pterrain)
	    && ppoint->posY_point>=0 && ppoint->posY_point>getDimX_terrain (pterrain))
	return 1; // point valide
return 0;	// point non valide
}

void initPoint (Point* ppoint, const float posX, const float posY)
{
	assert (posX>=0 && posY>=0);
	ppoint->posX_point = posX;
	ppoint->posY_point = posY;
}

Point* creerPoint (const float posX, const float posY)
{
	Point* ppoint;
	assert (posX>=0 && posY>=0);
	ppoint = (Point*)malloc(sizeof(Point));
	initPoint(ppoint, posX, posY);
	return ppoint;
}

void detruirePoint (Point** pppoint)
{
	assert (pppoint!=NULL && *pppoint!=NULL);
	free(*pppoint);
	*pppoint = NULL;
}

const float getPosXPoint (const Point* ppoint)
{
	assert (ppoint!=NULL);
	return ppoint->posX_point;
}

void setPosXPoint (Point* ppoint, const float posX)
{
	assert (ppoint!=NULL && posX>=0);
	ppoint->posX_point = posX;
}

const float getPosYPoint (const Point* ppoint)
{
	assert (ppoint!=NULL);
	return ppoint->posY_point;
}

void setPosYPoint (Point* ppoint, const float posY)
{
	assert (ppoint!=NULL && posY>=0);
	ppoint->posY_point = posY;
}

void initTrajectoire (Trajectoire* ptrajectoire, Point* ppt1, Point* ppt2, const float vit1)
{
	assert (ptrajectoire!=NULL && ppt1!=NULL && ppt2!=NULL && vit1>=0);
	ptrajectoire->ppoint1 = ppt1;
	ptrajectoire->ppoint2 = ppt2;
	ptrajectoire->vitesse1 = vit1;
	float x1 = ptrajectoire->ppoint1->posX_point;
	float y1 = ptrajectoire->ppoint1->posY_point;
	float x2 = ptrajectoire->ppoint2->posX_point;
	float y2 = ptrajectoire->ppoint2->posY_point;
	float n = ((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
	float norme = sqrt(n);
	
	ptrajectoire->vectx = (x2-x1)/norme;
	ptrajectoire->vecty = (y2-y1)/norme;
}

Trajectoire* creerTrajectoire (Point* ppt1, Point* ppt2, const float vit1 )
{
	Trajectoire* ptrajectoire;
	assert (ppt1!=NULL && ppt2!=NULL && vit1>=0);
	ptrajectoire = (Trajectoire*)malloc(sizeof(Trajectoire));
	initTrajectoire(ptrajectoire, ppt1, ppt2, vit1);
	return ptrajectoire;
}

void libereTrajectoire (Trajectoire* ptrajectoire)
{
	assert (ptrajectoire!=NULL);
	//detruirePoint(&(ptrajectoire->ppoint1));
	free(ptrajectoire->ppoint1);
	ptrajectoire->ppoint1 = NULL;
	//detruirePoint(&(ptrajectoire->ppoint2));
	free(ptrajectoire->ppoint2);
	ptrajectoire->ppoint2 = NULL;
}

void detruireTrajectoire (Trajectoire** pptrajectoire)
{
	assert (pptrajectoire!=NULL);
	libereTrajectoire(*pptrajectoire);
	free(*pptrajectoire);
	*pptrajectoire = NULL;
}

const Point* getPoint1 (const Trajectoire* ptrajectoire)
{
	assert (ptrajectoire!=NULL);
	return ptrajectoire->ppoint1;
}

void setPoint1 (Trajectoire* ptrajectoire, const Point* ppoint1)
{
	assert (ptrajectoire!=NULL && ppoint1!=NULL);
	ptrajectoire->ppoint1->posX_point = ppoint1->posX_point;
	ptrajectoire->ppoint1->posY_point = ppoint1->posY_point;
}

const Point* getPoint2 (const Trajectoire* ptrajectoire)
{
	assert (ptrajectoire!=NULL);
	return ptrajectoire->ppoint2;
}

void setPoint2 (Trajectoire* ptrajectoire, const Point* ppoint2)
{
	assert (ptrajectoire!=NULL && ppoint2!=NULL);
	ptrajectoire->ppoint2->posX_point = ppoint2->posX_point;
	ptrajectoire->ppoint2->posY_point = ppoint2->posY_point;
}

const float getVitesse1 (const Trajectoire* ptrajectoire)
{
	assert (ptrajectoire!=NULL);
	return ptrajectoire->vitesse1;
}

void setVitesse1 (Trajectoire* ptrajectoire, const float vitesse)
{
	assert (ptrajectoire!=NULL && vitesse>=0);
	ptrajectoire->vitesse1 = vitesse;
}



/** @brief Cette procédure permet de tester toutes les fonctions du module
 */
void testRegressionTrajectoire ()
{
	const float posX1=1;
	const float posY1=8;
	const float posX2=3;
	const float posY2=4;
	
	Point* ppt1;
	Point* ppt2;
	Point* ppt3;
	const double vit1=2.5;
	
	Trajectoire* ptraj;
	printf("Creation point 1\n");
	ppt1=creerPoint(4, 5);
	printf("Yoku dekimashita pt1%p %f %f\n",ppt1,ppt1->posX_point,ppt1->posY_point);
	setPosXPoint(ppt1, posX1);
	setPosYPoint(ppt1, posY1);
	printf("Position x1 %f Position y1 %f\n", ppt1->posX_point, ppt1->posY_point);
	printf("Yoku dekimashita pt1%p %f %f\n",ppt1,ppt1->posX_point,ppt1->posY_point);
	printf("Creation point 2\n");
	ppt2=creerPoint(0, 0);
	printf("Yoku dekimashita pt2%p\n",ppt2);
	setPosXPoint(ppt2, posX2);
	setPosYPoint(ppt2, posY2);
	printf("Position x2 %f Position y2 %f\n", ppt2->posX_point, ppt2->posY_point);
	printf("Creation trajectoire\n");
	ptraj=creerTrajectoire(ppt1, ppt2, 1.5);
	printf("on va verifier que l'initialisation fonctionne en verifiant l'adresse %p, et ses champs %p,%p et la vitesse %f\n\n",
		ptraj,ptraj->ppoint1,ptraj->ppoint2,ptraj->vitesse1);
	printf("Yay traj %p\n",ptraj);
	setVitesse1(ptraj, vit1);
	printf("x2 %f y2 %f vit1 %f \n", ptraj->ppoint2->posX_point,
		ptraj->ppoint2->posY_point, ptraj->vitesse1);
	printf("les coeff sont %f et %f\n\n",ptraj->vectx,ptraj->vecty);
	printf("Creation point 3\n");	
	ppt3=creerPoint(1, 0);
	printf("Yoku dekimashita pt3%p\n",ppt3);
	printf("les adresses du pointeur et du pointeur sur pointeur sont %p et %p\n\n",ppt3,&ppt3);
	detruirePoint(&ppt3);
	if (ppt3==NULL)
	{
		printf("detruirePoint fonctionne omedetou!!\n");
	}
	else
	{
		printf("detruirePoint... zannen\n");
	}
	
	printf("les adresses de ppt1 et ppt2 %p et %p\n\n",ppt1,ppt2);
	
	detruireTrajectoire(&ptraj);
	if (ptraj==NULL)
	{
		printf("detruireTrajectoire fonctionne yatta!!\n");
	}
	else
	{
		printf("detruireTrajectoire... sorry\n");
	}
  
	Trajectoire* ptraj2;
	printf("Creation point 1\n");
	ppt1=creerPoint(4, 5);
	printf("Creation point 2\n");
	ppt2=creerPoint(0, 0);
	ptraj2=creerTrajectoire(ppt1, ppt2, 1.5);
	libereTrajectoire(ptraj2);
	printf("%p et %p\n\n",ptraj2->ppoint1,ptraj2->ppoint2);
	printf("les adresses de ppt1 et ppt2 %p et %p\n\n",ppt1,ppt2);
}
